import request from "@/utils/request"

//区域
//添加区域
export const createAreaApi = (param) => {
    return request.post('/area/', param, {
        headers: {
            'Content-Type': 'application/json',  // 确保请求体是JSON格式
        }
    })
}
/**
 * 获取区域列表
 * @param {Object} params - 请求参数
 * @param {string} [params.company_id] - 公司ID，供平台管理员选择访问的id
 * @param {number} [params.limit] - 分页限制，每页显示的数量
 * @param {number} [params.offset] - 分页偏移，当前页码
 * @param {number} [params.merged_area_id] - 合并区域id
 * @returns {Promise<{
 *   message: string,
 *   code: number,
 *   areas: Array<{
 *     id: number, - 区域id
 *     name: string, - 区域名称
 *     company_id: number,  - 公司id
 *     energy_user_id: number, - 用能户id
 *     merged_area: Object|null, - 属于哪个合并区域信息
 *     ratio: string - 排水量占比
 *   }>
 * }>} 返回区域列表数据
 */
export const getAreaListApi = (params = {}) => {
    return request.get('/area/', { params });
};


//删除区域
export const deleteAreaApi = (id) => {
    return request.delete('/area/', {
        data: { id }
    });
}
/**
 * 修改区域信息
 * @param {Object} param - 请求参数
 * @param {number} param.id - ID 编号
 * @param {string} [param.name] - 区域名称
 * @param {number} [param.energy_user_id] - 能源用户ID
 * @param {number} [param.merged_area] - 合并区域ID
 * @param {string} [param.ratio] - 排水比例(0-1之间)
 * @returns {Promise<{
 *   message: string,
 *   code: number
 * }>} 返回修改结果
 */
export const updateAreaApi = (param) => {
    return request.patch('/area/', param)
}
export const getMergedAreaListApi = (params = {}) => {
    return request.get('/merged_area/', { params });
}
/**
 * 添加合并区域
 * @param {Object} param - 请求参数
 * @param {string} param.name - 合并区域名称
 * @param {number} param.company_id - 公司ID 
 * @param {number[]} param.area_ids - 区域ID数组
 * @returns {Promise<{
 *   code: 200,
 *   data: any,
 *   message: string
 * }>} 返回添加结果,成功时code为200
 */
export const addMergedAreaApi = (param) => {
    return request.post('/merged_area/', param)
}

/**
 * 修改合并区域
 * @param {Object} param - 请求参数
 * @param {number} param.id - 合并区域ID编号
 * @param {string} [param.name] - 合并区域名称
 * @param {number} [param.company_id] - 公司ID
 * @param {string} [param.ratio] - 排水比例(0-1之间)
 * @returns {Promise<{
 *   message: string,
 *   code: number
 * }>} 返回修改结果
 */
export const updateMergedAreaApi = (param) => {
    return request.patch('/merged_area/', param)
}

/**
 * 删除合并区域
 * @param {Object} param - 请求参数
 * @param {string} param.id - 合并区域ID编号
 * @returns {Promise<{
 *   message: string,
 *   code: number
 * }>} 返回删除结果
 */
export const deleteMergedAreaApi = (param) => {
    return request.delete('/merged_area/', { data: param })
}

/**
 * 获取区域分片数据
 * @param {Object} params
 * @param {Number} params.id 区域id
 * @param {Number} params.start_time 开始时间
 * @param {Number} params.end_time 结束时间
 * @param {Number} params.interval 时间间隔
 * @param {Number} params.type 表计类型
 * @returns {Promise}
 */

export function getAreaReportApi(params) {
    return request.get('/report/area', { params });
}

import dayjs from 'dayjs';

/**
 * 获取所有区域总共的数据
 * @param {Object} params
 * @param {Number} params.id 公司id
 * @param {Number|String} params.start_time 开始时间（13位时间戳或日期字符串）
 * @param {Number|String} params.end_time 结束时间（13位时间戳或日期字符串）
 * @param {Number} params.interval 时间间隔
 * @param {Number} params.type 表计类型
 */
export function getAllAreaReportApi(params) {
    // 基础参数验证
    if (!params?.id) {
        throw new Error('公司ID不能为空');
    }

    if (!params?.start_time || !params?.end_time) {
        throw new Error('开始时间和结束时间不能为空');
    }

    // 转换时间为13位时间戳
    const normalizedParams = {
        ...params,
        start_time: convertToTimestamp(params.start_time),
        end_time: convertToTimestamp(params.end_time)
    };

    // 如果没有interval，需要特殊处理
    if (!normalizedParams.interval) {
        // 检查时间跨度是否超过3个月
        const timeSpanMonths = calculateTimeSpanInMonths(normalizedParams.start_time, normalizedParams.end_time);

        if (timeSpanMonths > 3) {
            // 超过3个月，按月分批获取数据
            return getAreaDataByMonths(normalizedParams);
        } else {
            // 3个月内，按天获取然后聚合
            return getAreaDataByDays(normalizedParams);
        }
    }

    // 有interval时，直接请求
    return request.get('/report/area/total', {
        params: normalizedParams
    }).then(response => {
        // 验证并过滤数据
        if (!response?.aggregated_data || !Array.isArray(response.aggregated_data)) {
            throw new Error('数据格式错误');
        }

        // 过滤用量为0的区域
        response.aggregated_data = response.aggregated_data.map(dayData =>
            dayData.filter(area => parseFloat(area.usage) > 0)
        );

        return response;
    }).catch(error => {
        console.error('获取区域报表数据失败:', error.message || error);
        throw error;
    });
}

/**
 * 转换时间为13位时间戳
 * @param {Number|String} time - 时间（可以是时间戳、日期字符串等）
 * @returns {Number} 13位时间戳
 */
function convertToTimestamp(time) {
    if (!time) return null;

    // 如果已经是13位时间戳，直接返回
    if (typeof time === 'number' && time.toString().length === 13) {
        return time;
    }

    // 如果是10位时间戳，转换为13位
    if (typeof time === 'number' && time.toString().length === 10) {
        return time * 1000;
    }

    // 使用dayjs解析并转换为13位时间戳
    return dayjs(time).valueOf();
}

/**
 * 计算时间跨度（月数）
 * @param {Number} startTime - 开始时间（13位时间戳）
 * @param {Number} endTime - 结束时间（13位时间戳）
 * @returns {Number} 月数差
 */
function calculateTimeSpanInMonths(startTime, endTime) {
    const start = dayjs(startTime);
    const end = dayjs(endTime);

    const yearDiff = end.year() - start.year();
    const monthDiff = end.month() - start.month();

    return yearDiff * 12 + monthDiff + 1; // +1 因为包含起始月
}

/**
 * 生成月份时间段
 * @param {Number} startTime - 开始时间（13位时间戳）
 * @param {Number} endTime - 结束时间（13位时间戳）
 * @returns {Array} 月份时间段数组
 */
function generateMonthlyPeriods(startTime, endTime) {
    const periods = [];
    const start = dayjs(startTime);
    const end = dayjs(endTime);

    let current = start.startOf('month'); // 当月第一天

    while (current.isBefore(end) || current.isSame(end, 'month')) {
        const periodStart = current;
        const periodEnd = current.endOf('month'); // 当月最后一天

        // 确保不超过原始结束时间
        const actualEnd = periodEnd.isAfter(end) ? end : periodEnd;

        periods.push({
            start_time: periodStart.valueOf(), // 13位时间戳
            end_time: actualEnd.valueOf()      // 13位时间戳
        });

        // 移动到下一个月
        current = current.add(1, 'month').startOf('month');
    }

    return periods;
}

/**
 * 按月获取区域数据
 * @param {Object} params - 原始参数
 * @returns {Promise} 聚合后的响应
 */
async function getAreaDataByMonths(params) {
    try {
        const monthlyPeriods = generateMonthlyPeriods(params.start_time, params.end_time);
        const monthlyPromises = monthlyPeriods.map(period =>
            request.get('/report/area/total', {
                params: {
                    ...params,
                    start_time: period.start_time,
                    end_time: period.end_time,
                    interval: 'day'
                }
            })
        );

        const monthlyResponses = await Promise.all(monthlyPromises);

        // 合并所有月份的数据
        const allDailyData = [];
        monthlyResponses.forEach(response => {
            if (response?.aggregated_data) {
                allDailyData.push(...response.aggregated_data);
            }
        });

        // 聚合数据
        const aggregatedData = aggregateAreaDailyData(allDailyData, params);

        return {
            ...monthlyResponses[0], // 使用第一个响应的基本信息
            aggregated_data: [aggregatedData]
        };

    } catch (error) {
        console.error('按月获取区域报表数据失败:', error.message || error);
        throw error;
    }
}

/**
 * 按天获取区域数据
 * @param {Object} params - 原始参数
 * @returns {Promise} 聚合后的响应
 */
function getAreaDataByDays(params) {
    const requestParams = { ...params, interval: 'day' };

    return request.get('/report/area/total', {
        params: requestParams
    }).then(response => {
        // 验证响应数据
        if (!response?.aggregated_data || !Array.isArray(response.aggregated_data)) {
            throw new Error('数据格式错误');
        }

        // 聚合每天的数据
        const aggregatedData = aggregateAreaDailyData(response.aggregated_data, params);

        return {
            ...response,
            aggregated_data: [aggregatedData]
        };
    }).catch(error => {
        console.error('获取区域报表数据失败:', error.message || error);
        throw error;
    });
}

/**
 * 聚合每天的区域数据
 * @param {Array} dailyData - 按天分组的数据
 * @param {Object} originalParams - 原始请求参数
 * @returns {Array} 聚合后的数据
 */
function aggregateAreaDailyData(dailyData, originalParams) {
    if (!dailyData.length) return [];

    // 用于存储每个area_id的聚合数据
    const areaMap = new Map();

    // 遍历每天的数据
    dailyData.forEach(dayData => {
        dayData.forEach(areaItem => {
            const areaId = areaItem.area_id;
            const usage = parseFloat(areaItem.usage) || 0;

            // 跳过用量为0的区域
            if (usage === 0) return;

            if (areaMap.has(areaId)) {
                // 累加usage
                const existingItem = areaMap.get(areaId);
                existingItem.usage = (parseFloat(existingItem.usage) + usage).toString();

                // 合并错误信息
                if (areaItem.error && !existingItem.error) {
                    existingItem.error = areaItem.error;
                } else if (areaItem.error && existingItem.error) {
                    existingItem.error += '; ' + areaItem.error;
                }
            } else {
                // 创建新的聚合项
                areaMap.set(areaId, {
                    area_id: areaId,
                    start_time: dayjs(originalParams.start_time).format('YYYY-MM-DDTHH:mm:ssZ'),
                    end_time: dayjs(originalParams.end_time).format('YYYY-MM-DDTHH:mm:ssZ'),
                    usage: usage.toString(),
                    error: areaItem.error || ''
                });
            }
        });
    });

    // 转换为数组并按area_id排序，再次过滤确保没有0用量的数据
    return Array.from(areaMap.values())
        .filter(area => parseFloat(area.usage) > 0)
        .sort((a, b) => a.area_id - b.area_id);
}